Category Archives: OOP

Big iOS learning classic is back again

The very well-known Stanford University’s course CS193p (Developing Applications for iOS using SwiftUI) formerly using Swift, has been broadcasted again this year.

This is the second time the curse is entirely done in SwiftUI. The course is very similar to last years’ but has some new approaches and updates that might worth repeating.

Continue reading Big iOS learning classic is back again

Dependency injection

In software engineering, dependency injection is a technique in which an object receives other objects that it depends on. These other objects are called dependencies. In the typical “using” relationship the receiving object is called a client and the passed (that is, “injected“) object is called a service.

The code that passes the service to the client can be many kinds of things and is called the injector. Instead of the client specifying which service it will use, the injector tells the client what service to use. The “injection” refers to the passing of a dependency (a service) into the object (a client) that would use it.

Continue reading Dependency injection

SOLID PROGRAMMING – LISKOV SUBSTITUTION PRINCIPLE

Substitutability is a principle in object-oriented programming stating that, in a computer program, if S is a subtype of T, then objects of type T may be replaced with objects of type S (i.e. an object of type T may be substituted with any object of a subtype S) without altering any of the desirable properties of the program (correctness, task performed, etc.). More formally, the Liskov substitution principle (LSP) is a particular definition of a subtyping relation, called (strongbehavioral subtyping, that was initially introduced by Barbara Liskov in a 1987.

The Liskov Substitution Principle is the third of Robert C. Martin’s SOLID design principles. It extends the Open/Closed principle and enables you to replace objects of a parent class with objects of a subclass without breaking the application. This requires all subclasses to behave in the same way as the parent class.

Therefore:

Functions that use pointers or references to base classes must be able to use objects of derived classes without knowing it.” – Robert C. Martin

A violation of this behaviour would imply your code is not SOLID and it may be prone to malfunctioning.

What’s all the hype about the heap and Stack?

The terms Stack and Heap get thrown around a lot in the programming world. But what does it means? What is the difference between them and why should we care?

Introduction

To start, I would like to make a clarification on a possible misconception. Heap is referred here as a memory allocation technique, not as a data structure. Furthermore, when we speak about Heap as opposed to Stack, we do not mean two types of memory, what we mean is two ways of allocating memory.

When your code compiles (or run if interpreted), the compiler needs to consider how to allocate your variable definitions in memory. To understand this process, let’s first examine the pros and cons of each type of allocation.

Continue reading What’s all the hype about the heap and Stack?

Effortless Class Diagrams for all your golang needs

A picture is worth a thousand words.

If you agree that nothing paints a better picture of your software project like a well maintained UML class diagram, then this post is for you.

Motivation

I have been fascinated with Golang because of the versatility of the language. I wanted to take advantage of the Golang parser and a great software called PlantUML (http://plantuml.com/) to create a program that will translate my Golang code into a neat class diagram.

Continue reading Effortless Class Diagrams for all your golang needs

An easy way to make MVC great again!

If you are a professional iOS or Android developer and you explicitly manifest your love for MVC as base architecture for your Apps, you are a leper and would be ostracized. 

Nowadays the MVC is frowned upon and not in the favor of altruistic developers.  

Viper, React, MVVM, those are good, MVC is bad and crappy… 

Truth or myth? 

Well, MVC is old indeed and certainty it got its flaws, most common of all, the feared “massive view controllers”. 

 But although the new aforementioned architectures bring to the table some solutions to MVC intrinsic issues, they do have some flaws as well, yeah “nobody is perfect”.

MVC is great, programmers are just too careless.

Continue reading An easy way to make MVC great again!

iOS Singletons – Objective-C

A singleton is a special kind of class where only one instance of the class exists for the current process. (In the case of an iOS app, the one instance is shared across the entire app.) Some examples in UIKit are [UIApplication sharedApplication] (which returns the sole instance of the application itself), and [NSFileManager defaultManager] (which returns the file manager instance). Singletons can be an easy way to share data and common methods across your entire app.

Rather than create instances of the singleton class using alloc/init, you’ll call a class method that will return the singleton object. You can name the class method anything, but common practice is to call it sharedName or defaultName.

Header

Implementation